#include <iostream>
#include <string>
#include <stdlib.h>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <cstdio>

using namespace std;

const int basesize = 1024;
const int gargvnum = 64;
const int genvnum = 64; 

//全局的退出码
int exitcode = 0;

//全局的环境变量表
char* genv[genvnum];

//全局的命令行参数
char* gargv[gargvnum];
int gargc = 0;

//全局的当前的shell工作路径
char pwd_buffer[basesize];
char pwd_env[basesize+4];

//全局的重定向标记
const int NoneRedir = 0;
const int InputRedir = 1;
const int OutputRedir = 2;
const int AppendRedir = 3;

int redir = NoneRedir;
char* filename = nullptr;

#define TrimSpace(pos) do{\
    while(isspace(*pos)) {\
	pos++;\
    }\
}while(0)

//新增环境变量
void AddEnv(const char* newenv){
    int index = 0;
    while(genv[index]){
        index++;
    }

    genv[index] = (char*)malloc(strlen(newenv)+1);
    strncpy(genv[index], newenv, strlen(newenv)+1);
    genv[++index] = nullptr;
}

// 同步更新 genv 和实际环境变量
void SyncEnv(const char* env_str) {
    // 更新实际环境变量
    putenv((char*)env_str);
    
    // 更新 genv 数组
    char* eq_pos = strchr((char*)env_str, '=');
    if (!eq_pos) return;
    
    size_t key_len = eq_pos - env_str;
    for (int i = 0; genv[i]; i++) {
        if (strncmp(genv[i], env_str, key_len) == 0 && genv[i][key_len] == '=') {
            free(genv[i]);  // 释放旧值
            genv[i] = strdup(env_str);
            return;
        }
    }
    // 未找到则新增
    AddEnv(env_str);
}


//获取用户名
string GetUser(){
    string user = getenv("USER");
    return user.empty() ? "None" : user;
}
//获取主机名
string GetHostName(){
    string hostname = getenv("HOSTNAME");
    return hostname.empty() ? "None" : hostname;
}
//获取当前的工作路径
string GetPwd(){
    //通过系统调用获取当前的工作路径，推荐！
    if(getcwd(pwd_buffer, sizeof(pwd_buffer)) == nullptr) return "None";

    snprintf(pwd_env, sizeof(pwd_env), "PWD=%s", pwd_buffer); //格式化输入PWD的值
    SyncEnv(pwd_env); //当前工作路径修改的同时更新环境变量PATH
    
    return pwd_buffer;

    //通过环境变量获取当前的工作路径，不推荐，因为环境变量也需要维护
    //string pwd = getenv("PWD");
    //return pwd.empty() ? "None" : pwd;
}
//获取当前工作路径的最后一个目录
string LastDir(){
    string curr = GetPwd();
    if(curr == "/" || curr == "Node") return curr;

    size_t pos = curr.rfind("/");
    return curr.substr(pos+1);
}
//1.打印命令行提示符
void PrintCommandLine(){
    //printf("[%s@%s:%s]# ", GetUser().c_str(), GetHostName().c_str(), GetPwd().c_str());

    char buffer[basesize];
    snprintf(buffer, basesize, "[%s@%s:%s]# ", GetUser().c_str(), GetHostName().c_str(), LastDir().c_str());
    printf("%s", buffer);

    fflush(stdout);
}

//2.获取用户输入的命令行
bool GetCommandLine(char command_buffer[], int size){
    //用户输入的命令行是一个完整的字符串
    char* result = fgets(command_buffer, size, stdin);
    if(result == nullptr){
	return false;
    }
    command_buffer[strlen(command_buffer)-1] = '\0'; //清空用户输入的enter键，获取纯粹的命令
    if(strlen(command_buffer) == 0) return false; //如果获取的字符串为空，即用户只按了回车，就退回打印命令行提示符
    return true;
}

//重置命令行参数、重定向相关的全局变量
void ResetCommandLine(){

    memset(gargv, 0, gargvnum);
    gargc = 0;

    filename = nullptr;
    redir = NoneRedir;
}

//分析重定向问题
void AnalysisRedir(char command_buffer[], int len){
    int end = len - 1;
    while(end >= 0){
        if(command_buffer[end] == '<'){
	    //输入重定向
	    redir = InputRedir;
	    command_buffer[end] = '\0';
	    filename = &command_buffer[end+1];
	    TrimSpace(filename);
	    break;
	}
	else if(command_buffer[end] == '>'){
	    if(command_buffer[end-1] == '>'){
	        //追加重定向
		redir = AppendRedir;
		command_buffer[end-1] = '\0';
		command_buffer[end] = '\0';
		filename = &command_buffer[end+1];
	        TrimSpace(filename);
		break;
	    }
	    else{
	        //输出重定向
		redir = OutputRedir;
		command_buffer[end] = '\0';
		filename = &command_buffer[end+1];
	        TrimSpace(filename);
		break;
	    }
	}
	else{
	    end--;
	}
    }
}

//分析命令
void AnalysisCommand(char command_buffer[]){
    const char* sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);//第一次调用strtok，第一个参数直接传要切割的内容

    while(gargv[gargc++] = strtok(nullptr, sep));//这里是多次调用strtok，所以strtok的第一个参数传递nullptr，表示切割历史的最近一个字符串
    gargc--; //上一行碰到了nullptr，gargc还做了一次++,所以这里就--
}

//3.分析命令行：把获取的命令行形成一张全局的命令行参数表
void AnalysisCommandLine(char command_buffer[], int len){
    //(void)len;//传进来的len没有使用，防止报警告
    
    //重定向之前的测试
    //printf("start:%s\n", command_buffer);

    //在本次分析之前，需要把上次形成的命令行参数表清空(命令是一直循环进行的)
    ResetCommandLine();

    //处理重定向问题
    //"ls -l -a" 
    //"ls -l -a" > file.txt
    //"ls -l -a" >> file.txt
    //"ls -l -a" < file.txt
    AnalysisRedir(command_buffer, len);
    
    //重定向之后的测试
    //printf("end:%s\n", command_buffer);
    //printf("redir:%d\n", redir);
    //printf("filename:%s\n", filename);

    AnalysisCommand(command_buffer);
}

void debug(){
    printf("argc:%d\n", gargc);
    for(int i = 0; gargv[i]; i++){
    	printf("argv[%d]:%s\n", i, gargv[i]);
    }
}

enum{
    FILE_OPEN_FAIL=1,
    FILE_NOT_EXISTS,
};

//执行重定向
void ExecuteRedir(){
    if(redir == InputRedir){
        if(filename){
	    int fd = open(filename, O_RDONLY);
	    if(fd < 0){
	        exit(FILE_OPEN_FAIL);//文件打开失败
	    }
	    dup2(fd, 0);
	}
	else exit(FILE_NOT_EXISTS);//文件不存在
    }
    else if(redir == OutputRedir){
        if(filename){
	    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
	    if(fd < 0){
	        exit(FILE_OPEN_FAIL);//文件打开失败
	    }
	    dup2(fd, 1);
	}
	else exit(FILE_NOT_EXISTS);//文件不存在
    }
    else if(redir == AppendRedir){
        if(filename){
	    int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);
	    if(fd < 0){
	        exit(FILE_OPEN_FAIL);//文件打开失败
	    }
	    dup2(fd, 1);
	}
	else exit(FILE_NOT_EXISTS);//文件不存在
    }
    else{
        //没有重定向，do nothing
    }

}

//5.执行命令:shell不能自己去执行，否则一旦遇到错误就崩了，所以需要创建子进程去执行
bool ExecuteCommand(){
    pid_t id = fork();
    if(id < 0) return false;
    else if(id == 0){
    	//子进程
	//1.执行重定向
	ExecuteRedir();
	//2.执行命令
	execvpe(gargv[0], gargv, genv);
	//3.执行完就退出
	exit(4);
    }
    //父进程
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0){
    	//成功回收子进程
	if(WIFEXITED(status)){
	    //子进程成功完成任务
	    exitcode = WEXITSTATUS(status);
	}
	else{
	    //子进程的任务没有成功完成
	    exitcode = 100;
	}
	return true;
    }
    return false;
}

//4.检查并执行内建命令
bool CheckAndExecuteBuiltCommand(){
    if(strcmp(gargv[0], "cd") == 0){
        if(gargc == 2){
            chdir(gargv[1]);
	    exitcode = 0;
        }
	else{
	    exitcode = 1;
	}
        return true;
    }
    else if( strcmp(gargv[0], "export") == 0 ){
	if(gargc == 2){
            SyncEnv(gargv[1]); //新增环境变量
	    exitcode = 0;
	}
	else{
	    exitcode = 2;
	}
	return true;
    }
    else if( strcmp(gargv[0], "env") == 0){
	for(int i = 0; genv[i]; i++){
            printf("%s\n", genv[i]);
        }
	exitcode = 0;
        return true;
    }
    else if(strcmp(gargv[0], "echo") == 0){
	if(gargc == 2){
	    if(gargv[1][0] == '$'){
		if(gargv[1][1] == '?'){
		    printf("%d\n", exitcode);
		    exitcode = 0;
		}
	    }
	    else{
	        printf("%s\n", gargv[1]);
		exitcode = 0;
	    }
	}
	else{
	    exitcode = 3;
	}
	return true;
    }
    return false;
}

//拷贝父shell的环境变量来初始化myshell的环境变量表
void InitEnv(){
    extern char** environ;
    int index = 0;
    while(environ[index]){
	genv[index] = (char*)malloc(strlen(environ[index])+1);
    	strncpy(genv[index], environ[index], strlen(environ[index])+1);
	index++;
    }
    genv[index] = nullptr; //最后一个值要置为nullptr
}


int main(){
    InitEnv();
    char command_buffer[basesize];//存放获取到的用户输入的命令
    while(1){
    	PrintCommandLine(); //1.打印命令行提示符
	//sleep(50);
    
	//command_buffer是一个输出型参数
    	if( !GetCommandLine(command_buffer, basesize) )  //2.获取用户输入的命令行
	{
	    continue;//获取失败就重新获取
	}
	//printf("%s\n", command_buffer);

    	AnalysisCommandLine(command_buffer, strlen(command_buffer)); //3.分析命令行
	//debug();
	
	//4.检查是否为内建命令，如果是，shell进程自己完成
	if( CheckAndExecuteBuiltCommand() ){
	    continue;
	}

    	ExecuteCommand();  //5.子进程执行命令
    }
    return 0;
}
